
\documentclass[10pt,a4paper]{article}
\usepackage[latin1]{inputenc}
\usepackage{graphicx}
\newtheorem{defi}{D\'efinition}
\newtheorem{theo}{Th\'eor\`eme}
\newtheorem{alg}{Algorithme}
\newtheorem{prop}{Proposition}
\newcommand{\proof}{{\bf D\'emonstration }}
\newcommand{\remark}{{\bf Remarque }}
\begin{document}

\title{Projet Circuits Digitaux Synchrones}
\date{Microprocesseur VISA}
\author{ Mathieu Barbin, Ocan Sankur (ENS)}


\maketitle

\section{Architecture du microprocesseur}
\paragraph~
Le microprocesseur est constitu\'e principalement de deux parties: le lecteur d'instructions et l'ALU. Le lecteur d'instructions
lit une instruction de la ROM qui contient le microcode, et puis incr\'emente la valeur de PC, le registre contenant le num\'ero de ligne qu'on va lire la prochaine
fois. En suite, l'ALU r\'ealise l'op\'eration demand\'ee et modifie \'eventuellement ses registres internes (R0, R1 et F), la RAM ou le registre PC.
Le diagramme suivant r\'esume le fonctionnement du microprocesseur.
\paragraph~
	\mbox{\includegraphics[scale=0.3]{micro_gen.eps}}
\paragraph~
Les registres internes R0 et R1 de l'ALU sont les op\'erandes des op\'erations arithm\'etiques et logiques.
L'accumulateur est R1, c'est-\`a-dire qu'on stocke toujours le r\'esultat d'une op\'eration dans R1. S'il y a eu d\'ebordement lors d'une op\'eration d'addition
ou de multiplication, le registre F, \`a 1 bit, prend la valeur 1; sinon il est \`a 0.
\paragraph~
L'architecture du microprocesseur fixe la taille des mots \`a 8 bits. 
En particulier, R0, R1 et PC sont des registres \`a 8 bits. Les m\'emoires ROM et RAM sont aussi \`a 8 bits d'adresses et 8 bits de donn\'ees par adresse.
Donc la ROM du microcode et la RAM ont tous les deux une capacit\'e de 256 octets.
\paragraph~
Le circuit contient aussi une sortie mat\'eriel controll\'ee par l'ALU. Cette sortie est divis\'ee en 255  adresses de sorties ($1..255$), avec chacune 8 bits de donn\'ees.
L'\'ecriture se fait en deux \'etapes: On \'ecrit d'abord l'adresse de sortie ($1..255$) \`a l'adresse 255, comme si on \'ecrivait dans la RAM. En suite on \'ecrit les 8 bits de donn\'ees
\`a cette adresse. Donc au niveau de programmation, tout se passe comme si on \'ecrivait ces deux mots dans la RAM \`a l'adresse 255, mais les donn\'ees sont orient\'ees vers la sortie mat\'eriel.
Le dernier octet de la RAM est donc inacc\'essible pour ce microprocesseur.\\
En particulier, pour la r\'ealisation de la montre digitale, nous utilisons cette sortie pour brancher `le mat\'eriel' afficheurs 7-segments.
\section{Langage et Compilateur/Simulateur}
\subsection{Les instructions}
Le langage d'assembleur du microprocesseur permet de lire un mot de la RAM, faire des op\'erations sur les registres R0 et R1 et de r\'e\'ecrire soit dans la RAM soit dans la sortie mat\'eriel.
Le langage contient les mneumonics suivants:
\paragraph~
\begin{tabular}{l|l}
	NOP & ne fait rien \\
	ADD & additionne R0 et R1\\
	MULT & multiplie R0 et R1\\
	AND & et bit-\`a-bit R0 et R1\\
	SWC & commute R0 et R1\\
	CMP & 1 si R0=R1 0 sinon \\
	NOT \textit{R}& non bit-\`a-bit du registre \textit{R}\\
	GF & r\'ecup\`ere la valeur du flag F dans R1\\
	JMP \textit{N}& aller \`a la ligne \textit{N}\\
	JMZ \textit{N}& aller \`a si R1=0\\
	JMN \textit{N}& aller \`a si R1$\neq$0\\
	STORE \textit{R}, \textit{N}& \'ecrit le contenu du registre \textit{R} \`a l'adresse \textit{N}\\
	LOAD \textit{N}, \textit{R}& \'ecrire le mot d'adresse
        \textit{N} de la RAM dans le registre \textit{R}\\
	SLEEP & dormir jusqu'\`a la fin de la seconde\\
\end{tabular}
\paragraph~
Le microprocesseur a la propri\'et\'e de se r\'eveiller toutes les secondes,
   qu'il soit en veille ou non. La commande SLEEP permet de le mettre en veille jusqu'\`a la fin de la seconde en cours.
   On peut donc synchroniser les op\'erations p\'eriodiques, en particulier, le calcul de l'heure \`a chaque seconde.
\subsection{Simulateur/Assembleur}
Nous avons r\'ealis\'e un assembleur du langage qu'on vient de
pr\'esenter. L'assembleur \textit{visa} \footnote{en hommage \`a la
  chanson 'Visa' de Charlie
  Parker, consid\'er\'e comme l'inventeur du style Bebop }(Visa IS an Assembler) est en m\^eme temps
un assembleur et un simulateur du microprocesseur muni d'une RAM \`a 256 octets. \textit{Visa} \'etend le langage d'assemblage en introduisant la
possibilit\'e de d\'efinir des valeurs constantes (macros) et des fonctions inline. Un programme \textit{visa} est constitu\'e d'une partie d'en-t\^ete
constitu\'ee des d\'efinitions de fonctions et des constantes, suivie du corps du programme.
\\Pour \'eviter les erreurs de programmations, le compilateur ne permet pas le branchement (par \textit{jmp}) direct aux num\'eros de ligne de codes, mais oblige l'utilisation
des \'etiquettes. Le programme suivant est extrait du code de la montre digitale.\\
Dans cet exemple, on d\'efinit la fonction \textit{increment} qui prend en argument la variable \`a incr\'ementer, la valeur modulo et deux \'etiquettes
\`a brancher selon le cas. On remarque que dans le corps de la fonction, les param\`etres sont pr\'ec\'ed\'es du signe \$. Dans tout le code, les
valeurs num\'eriques sont pr\'ec\'ed\'es du signe \#, et les \'etiquettes de @. 

\begin{verbatim}
define year 0
define sec 1
define min 2
define hour 3
macro increment var,modulo,return_label, carry_label
    load $var,R0
    load #1,R1
    add
    store R1,$var
    load $modulo,R0
    cmp
    jmn $carry_label
    jmp $return_label
end
start
//calcul du fevrier:
load year,R0
load #3,R1
and
jmz @28
jmn @30
28: load #28,R0
jmp @FEB_WRITE
30: load #30,R0
FEB_WRITE: store R0,2

//MAIN PROGRAM
COUNT_SEC: increment sec,#60,@COUNT_SEC,@COUNT_MIN

COUNT_MIN: load #0,R0
store R0,sec
increment min,#60,@COUNT_SEC,@COUNT_HOUR

COUNT_HOUR: load #0,R0
store R0,min
increment hour,#24,@COUNT_SEC,@COUNT_DAY

(...)
\end{verbatim}
\end{document}

